package com.innovations.inn.service.impl;

import com.innovations.common.utils.DateUtils;
import com.innovations.common.utils.uuid.IdGeneratorSnowflake;
import com.innovations.inn.domain.Enterprise;
import com.innovations.inn.domain.EnterpriseModify;
import com.innovations.inn.domain.EnterpriseQualification;
import com.innovations.inn.domain.request.RequestEnterpriseInfoAll;
import com.innovations.inn.domain.response.ResponseEnterpriseModifyInfo;
import com.innovations.inn.domain.response.ResponseEnterpriseModifyInfoAll;
import com.innovations.inn.domain.response.ResponseItemCount;
import com.innovations.inn.mapper.EnterpriseModifyMapper;
import com.innovations.inn.service.IEnterpriseModifyService;
import com.innovations.inn.service.IEnterpriseQualificationService;
import com.innovations.inn.service.IEnterpriseService;
import java.beans.Transient;
import java.util.List;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import static com.innovations.common.utils.MyBeanUtils.copyProperties;

/**
 * 企业信息修改记录Service业务层处理
 *
 * @author dp
 * @date 2024-11-08
 */
@Slf4j
@Service
public class EnterpriseModifyServiceImpl implements IEnterpriseModifyService {
    @Autowired
    EnterpriseModifyMapper enterpriseModifyMapper;
    @Autowired
    IdGeneratorSnowflake idGeneratorSnowflake;
    @Autowired
    private IEnterpriseQualificationService enterpriseQualificationService;
    @Autowired
    private IEnterpriseService enterpriseService;

    /**
     * 查询企业信息修改记录
     *
     * @param enterpriseId 企业信息修改记录主键
     * @return 企业信息修改记录
     */
    @Override
    public EnterpriseModify selectEnterpriseModifyByEnterpriseId(Long enterpriseId) {
        return enterpriseModifyMapper.selectEnterpriseModifyByEnterpriseId(enterpriseId);
    }

    /**
     * 查询企业信息修改记录列表
     *
     * @param enterpriseModify 企业信息修改记录
     * @return 企业信息修改记录
     */
    @Override
    public List<EnterpriseModify> selectEnterpriseModifyList(EnterpriseModify enterpriseModify) {
        return enterpriseModifyMapper.selectEnterpriseModifyList(enterpriseModify);
    }

    /**
     * 查询企业详细信息列表
     *
     * @param enterpriseModify 企业信息修改记录
     * @return 企业信息修改记录
     */
    @Override
    public List<ResponseEnterpriseModifyInfo> selectEnterpriseModifyListInfo(EnterpriseModify enterpriseModify) {
        return enterpriseModifyMapper.selectEnterpriseModifyListInfo(enterpriseModify);
    }

    /**
     * 查询企业及资质详细信息列表
     *
     * @param enterpriseModify 企业信息修改记录
     * @return 企业信息修改记录
     */
    @Override
    public List<ResponseEnterpriseModifyInfoAll> selectEnterpriseModifyListInfoAll(EnterpriseModify enterpriseModify) {
        return enterpriseModifyMapper.selectEnterpriseModifyListInfoAll(enterpriseModify);
    }

    /**
     * 查询企业及资质详细信息合计
     *
     * @param enterpriseModify 企业信息修改记录
     * @return 企业信息修改记合计
     */
    @Override
    public List<ResponseItemCount> selectEnterpriseModifyListInfoAllCount(EnterpriseModify enterpriseModify) {
        return enterpriseModifyMapper.selectEnterpriseModifyListInfoAllCount(enterpriseModify);
    }

    /**
     * 校验企业信息修改记录是否唯一
     *
     * @param enterpriseModify 企业信息修改记录
     * @return 结果
     */
    @Override
    public boolean checkEnterpriseModifyUnique(EnterpriseModify enterpriseModify) {
        //如果当前为提交审核状态，则校验是否存在未审核的记录
        if (enterpriseModify.getState() == 1) {
            //判断是否存在未审核的修改记录
            EnterpriseModify enterpriseModifyQuery = new EnterpriseModify();
            enterpriseModifyQuery.setEnterpriseId(enterpriseModify.getEnterpriseId());
            enterpriseModifyQuery.setState(1L);
            List<EnterpriseModify> enterpriseModifies = enterpriseModifyMapper.selectEnterpriseModifyList(enterpriseModifyQuery);

            return enterpriseModifies == null || enterpriseModifies.isEmpty();
        }
        return true;
    }

    /**
     * 新增企业信息修改记录
     *
     * @param enterpriseModify 企业信息修改记录
     * @return 结果
     */
    @Override
    public int insertEnterpriseModify(EnterpriseModify enterpriseModify) {
        // 新增等同于提交
        enterpriseModify.setSubmitBy(enterpriseModify.getUserId());
        enterpriseModify.setSubmitTime(DateUtils.getNowDate());
        return enterpriseModifyMapper.insertEnterpriseModify(enterpriseModify);
    }

    /**
     * 新增企业及资质信息
     *
     * @param input 企业及资质信息
     * @return 结果
     */
    @Override
    @Transient
    public int insertEnterpriseAll(RequestEnterpriseInfoAll input) {
        try {
            // 添加修改记录
            EnterpriseModify enterpriseModify = copyProperties(input, EnterpriseModify.class);
            enterpriseModifyMapper.insertEnterpriseModify(enterpriseModify);
            // 添加资质信息
            EnterpriseQualification enterpriseQualification = copyProperties(input, EnterpriseQualification.class);
            enterpriseQualificationService.insertEnterpriseQualification(enterpriseQualification);
        } catch (Exception e) {
            log.error("新增企业信息修改记录失败", e);
            return 0;
        }
        return 1;
    }

    /**
     * 修改企业信息修改记录
     *
     * @param enterpriseModify 企业信息修改记录
     * @return 结果
     */
    @Override
    public int updateEnterpriseModify(EnterpriseModify enterpriseModify) {
        // 状态为审核通过时，添加商业信息
        if (enterpriseModify.getState() == 2) {
            // 获取企业信息
            Enterprise enterprise = enterpriseService.selectEnterpriseByEnterpriseId(enterpriseModify.getEnterpriseId());
            Enterprise enterpriseNew = copyProperties(enterpriseModify, Enterprise.class);
            // 新增或修改企业信息
            if (enterprise == null || enterprise.getEnterpriseId() == null) {
                enterpriseService.insertEnterprise(enterpriseNew);
            } else {
                enterpriseService.updateEnterprise(enterpriseNew);
            }
        }
        // 更新企业信息修改记录
        return enterpriseModifyMapper.updateEnterpriseModify(enterpriseModify);
    }

    /**
     * 批量删除企业信息修改记录
     *
     * @param enterpriseIds 需要删除的企业信息修改记录主键
     * @return 结果
     */
    @Override
    public int deleteEnterpriseModifyByEnterpriseIds(Long[] enterpriseIds) {
        return enterpriseModifyMapper.deleteEnterpriseModifyByEnterpriseIds(enterpriseIds);
    }

    /**
     * 删除企业信息修改记录信息
     *
     * @param enterpriseId 企业信息修改记录主键
     * @return 结果
     */
    @Override
    public int deleteEnterpriseModifyByEnterpriseId(Long enterpriseId) {
        return enterpriseModifyMapper.deleteEnterpriseModifyByEnterpriseId(enterpriseId);
    }

    /**
     * 实体数据补全
     *
     * @param enterpriseModify 实体
     * @param userId           用户id
     * @param crateType        创建类型 1：新增 2：修改
     */
    @Override
    public void completeData(EnterpriseModify enterpriseModify, Long userId, Integer crateType) {
        // 修改记录标识
        if (enterpriseModify.getModifyId() == null) {
            enterpriseModify.setModifyId(idGeneratorSnowflake.nextId());
        }
        // 企业标识
        if (enterpriseModify.getEnterpriseId() == null) {
            // 根据企业名称获取企业标识
            Enterprise enterprise = new Enterprise();
            enterprise.setEnterpriseName(enterpriseModify.getEnterpriseName());
            List<Enterprise> enterpriseList = enterpriseService.selectEnterpriseList(enterprise);
            // 判断企业列表为空，则创建新企业标识
            if (enterpriseList == null || enterpriseList.isEmpty()) {
                enterpriseModify.setEnterpriseId(idGeneratorSnowflake.nextId());
            } else {
                enterpriseModify.setEnterpriseId(enterpriseList.get(0).getEnterpriseId());
            }
        }
        // 创建模式
        if (crateType == 1) {
            // 创建人
            if (enterpriseModify.getUserId() == null) {
                enterpriseModify.setUserId(userId);
            }
            // （企业）状态:0.创建 1.提交 2.审核 3.拒审
            if (enterpriseModify.getState() == null) {
                enterpriseModify.setState(0L);
            }
        }
        // 修改模式
        else if (crateType == 2) {
            // 判断如果为【2】审核状态，且未审核过，则添加审核人、审核时间
            if (enterpriseModify.getState() == 2 && enterpriseModify.getAuditBy() == null) {
                enterpriseModify.setAuditBy(userId);
                enterpriseModify.setAuditTime(DateUtils.getNowDate());
            }
        }
//        // 逻辑删除
//        if (enterpriseModify.getIsDeleted() == null || "".equals(enterpriseModify.getIsDeleted())) {
//            enterpriseModify.setIsDeleted(0L);
//        }
    }

}
